1. Field of the Invention
This invention pertains to software debuggers used to debug applications running on remote computers and, more particularly, to the way these debuggers manage, access and view memory regains used by the software applications on the remote computers.
2. Description of the Related Art
Embedded computers are being used in a variety of applications ranging from home appliances to aircraft control. Since these computers are mainly used to control a variety of equipment, they do not have a keyboard or a video display such as used with personal computers. In most cases these computers would have a limited number of keys or sensors for inputs and some light indicators (LED) or a small display screen for outputs. During the development of software or firmware applications for these computers, the developers tend to use a host computer, which is normally a PC or a work station, to run the software debugger to develop the applications. This concept is normally called software remote debugging since the debugger is running on the host computer and the application is running on the embedded computer which is also referred to as the target system. During the debug process, the debugger that is running on the host computer would be connected via a debug link to the application that is running on the embedded computer. This debug link is normally used to download the application, read and write memory locations and CPU register information on the remote computer. It is also very common to use an emulator to make the connection between the host computer and the target system. The emulator would normally connect to the host computer via a USB, Ethernet or similar connection and to the embedded computer via a JTAG or a similar type of debug ports. The emulator would use the debug port to control the application execution and access the target system resources.
During the software development process, it is very useful to have the ability to access the application memory space in different ways. One example is the way to handle the CPU cache system during memory access. In such example, the debugger can view the memory as it is stored in the CPU cache or as it is stored in the system memory outside the CPU. Another example is the way data gets written into the memory space. The debugger can request the data to be written directly to the memory after switching the CPU data cache off or written first to the CPU cache and then forwarded to the main memory.
The target system would normally have a memory management system (MMU) to manage cache support but target application cache setup does not always match the debugger requirements.
Another situation is when writing FLASH memory. Unlike random access memory, the system has to use an algorithm to write the FLASH memory. In the prior art, the user has to engage a FALSH programmer to program the FLASH memory during application download and then engage the debugger. If the debugger has the FLASH address information, it can engage the FALSH writing algorithm when it needs to write the flash memory during a debug session.
Providing the debugger with such information is very helpful during debugging. This will allow the user to access different blocks of memory in the target system in different ways. This helps the user of the debugger to view and get the information needed without having to call multiple applications or adjust the MMU unit in the target system to access specific memory reigns in different ways and then readjust the MMU parameters for the system to continue execution after accessing the data.